package com.riant.day06;

import java.io.Serializable;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * @Classname ArrayAlg
 * @Description TODO
 * @Date 2021/3/17 21:54
 * @Created by 张斌
 */
public class ArrayAlg {
    /**
     * 计算数组中最小的元素，
     * 需要对T泛型话参数进行限制，必须要实现Comparable接口
     * */

    public static <T extends Comparable & Serializable> T smallest(T[] t){
        if(t==null||t.length==0)
            return null;
        T small=t[0];
        for(int i=1;i<t.length;i++){
            if(small.compareTo(t[i])>0){
                small=t[i];
            }
        }
        return small;
    }

    public static <T extends Comparable,E extends Comparable> E smallest(Map<T,E> map){
        Iterator iterator=map.entrySet().iterator();
        if(map==null){
            return null;
        }
        T temp=null;
        int[] arr=new int[10];
        /**
         * T[] tempArr=new T[map.size()];
         * 编译错误。会在运行时擦除
         * 解决方法：在想要创建泛型数组的地方使用ArrayList
         *   List<T> list = new ArrayList<>();
         *   成功创建泛型数组的唯一方式就是创建一个被擦除类型的新数组，然后对其转型
         *    T[] list = (T[]) new Object[capacity];
         * */
        T[] list = (T[]) new Object[10];
        Set<Map.Entry<T, E>> entries=map.entrySet();
        int i=0;
        T small=null;
        for(Map.Entry<T,E> entry:entries){
            if(i==0){
                small=entry.getKey();
            }else{
                if(small.compareTo(entry.getKey())<0){
                    small=entry.getKey();
                }
            }
        }
        return map.get(small);
    }

    public static void main(String[] args) {
        Map<Integer, Integer> map=new HashMap<Integer, Integer> ();
        map.put(1,1);
        map.put(2,2);
        map.put(3,3);
        map.put(4,4);
        System.out.println(smallest(map));
    }
}
